LCOV - code coverage report
Current view: top level - src - tls_openssl.c (source / functions) Coverage Total Hit
Test: coverage.info Lines: 21.8 % 568 124
Test Date: 2025-01-14 00:00:00 Functions: 32.5 % 40 13

            Line data    Source code
       1              : /* SPDX-License-Identifier: MIT OR GPL-3.0-only */
       2              : /* tls_openssl.c
       3              : ** strophe XMPP client library -- TLS abstraction openssl impl.
       4              : **
       5              : ** Copyright (C) 2005-008 Collecta, Inc.
       6              : **
       7              : **  This software is provided AS-IS with no warranty, either express
       8              : **  or implied.
       9              : **
      10              : **  This program is dual licensed under the MIT or GPLv3 licenses.
      11              : */
      12              : 
      13              : /** @file
      14              :  *  TLS implementation with OpenSSL.
      15              :  */
      16              : 
      17              : #include <errno.h> /* EINTR */
      18              : #include <string.h>
      19              : 
      20              : #ifndef _WIN32
      21              : #include <sys/select.h>
      22              : #else
      23              : #include <winsock2.h>
      24              : #endif
      25              : 
      26              : #include <openssl/ssl.h>
      27              : #include <openssl/err.h>
      28              : #include <openssl/opensslv.h>
      29              : #include <openssl/x509v3.h>
      30              : #include <openssl/pkcs12.h>
      31              : 
      32              : #include "common.h"
      33              : #include "tls.h"
      34              : #include "sock.h"
      35              : 
      36              : /*
      37              :  * Redefine OPENSSL_VERSION_NUMBER for LibreSSL.
      38              :  * LibreSSL and OpenSSL use different and incompatible version schemes. Solve
      39              :  * this issue in the way how nginx project did.
      40              :  */
      41              : #if (defined LIBRESSL_VERSION_NUMBER && OPENSSL_VERSION_NUMBER == 0x20000000L)
      42              : #undef OPENSSL_VERSION_NUMBER
      43              : #if (LIBRESSL_VERSION_NUMBER >= 0x2080000fL)
      44              : #define OPENSSL_VERSION_NUMBER 0x1010000fL
      45              : #elif (LIBRESSL_VERSION_NUMBER >= 0x2070000fL)
      46              : #define OPENSSL_VERSION_NUMBER 0x1000200fL
      47              : #else
      48              : #define OPENSSL_VERSION_NUMBER 0x1000107fL
      49              : #endif
      50              : #endif
      51              : 
      52              : #if OPENSSL_VERSION_NUMBER < 0x30000000L
      53              : #define STROPHE_ERR_func_error_string(e) ERR_func_error_string(e)
      54              : #define STROPHE_SSL_get1_peer_certificate(s) SSL_get_peer_certificate(s)
      55              : #else
      56              : #define STROPHE_ERR_func_error_string(e) ""
      57              : #define STROPHE_SSL_get1_peer_certificate(s) SSL_get1_peer_certificate(s)
      58              : #endif
      59              : 
      60              : #if OPENSSL_VERSION_NUMBER < 0x10100000L
      61              : static const unsigned char *ASN1_STRING_get0_data(ASN1_STRING *asn1)
      62              : {
      63              :     return ASN1_STRING_data(asn1);
      64              : }
      65              : #endif
      66              : 
      67              : #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined LIBRESSL_VERSION_NUMBER
      68              : static int SSL_CTX_use_cert_and_key(SSL_CTX *ctx,
      69              :                                     X509 *x509,
      70              :                                     EVP_PKEY *privatekey,
      71              :                                     STACK_OF(X509) * chain,
      72              :                                     int override)
      73              : {
      74              :     UNUSED(override);
      75              :     if (!ctx)
      76              :         return 0;
      77              :     if (x509 && !SSL_CTX_use_certificate(ctx, x509))
      78              :         return 0;
      79              :     if (privatekey && !SSL_CTX_use_PrivateKey(ctx, privatekey))
      80              :         return 0;
      81              : #ifdef SSL_CTX_set1_chain
      82              :     if (chain && !SSL_CTX_set1_chain(ctx, chain))
      83              :         return 0;
      84              : #else
      85              :     UNUSED(chain);
      86              : #endif
      87              :     return 1;
      88              : }
      89              : #endif
      90              : 
      91              : #if OPENSSL_VERSION_NUMBER < 0x10000000L
      92              : static int GENERAL_NAME_get0_otherName(const GENERAL_NAME *gen,
      93              :                                        ASN1_OBJECT **poid,
      94              :                                        ASN1_TYPE **pvalue)
      95              : {
      96              :     if (gen->type != GEN_OTHERNAME)
      97              :         return 0;
      98              :     if (poid)
      99              :         *poid = gen->d.otherName->type_id;
     100              :     if (pvalue)
     101              :         *pvalue = gen->d.otherName->value;
     102              :     return 1;
     103              : }
     104              : #endif
     105              : 
     106              : struct _tls {
     107              :     xmpp_ctx_t *ctx;
     108              :     sock_t sock;
     109              :     SSL_CTX *ssl_ctx;
     110              :     SSL *ssl;
     111              :     X509 *client_cert;
     112              :     void *channel_binding_data;
     113              :     size_t channel_binding_size;
     114              :     FILE *keylogfile;
     115              :     int lasterror;
     116              : };
     117              : 
     118              : enum {
     119              :     TLS_SHUTDOWN_MAX_RETRIES = 10,
     120              :     TLS_TIMEOUT_SEC = 0,
     121              :     TLS_TIMEOUT_USEC = 100000,
     122              : };
     123              : 
     124              : static void _tls_sock_wait(tls_t *tls, int error);
     125              : static const char *_tls_error_str(int error, const char **tbl, size_t tbl_size);
     126              : static void _tls_set_error(tls_t *tls, int error);
     127              : static void _tls_log_error(xmpp_ctx_t *ctx);
     128              : static void _tls_dump_cert_info(tls_t *tls);
     129              : static X509 *_tls_cert_read(xmpp_conn_t *conn);
     130              : static X509 *
     131              : _tls_cert_read_p12(xmpp_conn_t *conn, EVP_PKEY **pkey, STACK_OF(X509) * *ca);
     132              : static int _tls_xaddr_nid(void);
     133              : static int _tls_xmppaddr_to_string(GENERAL_NAME *name, char **res);
     134              : static int _tls_dnsname_to_string(GENERAL_NAME *name, char **res);
     135              : static GENERAL_NAMES *_tls_conn_get_names(xmpp_conn_t *conn);
     136              : static GENERAL_NAMES *_tls_cert_get_names(X509 *client_cert);
     137              : 
     138              : #define TLS_ERROR_STR(error, table) \
     139              :     _tls_error_str(error, table, ARRAY_SIZE(table))
     140              : 
     141              : #define TLS_ERROR_FIELD(x) [x] = #x
     142              : const char *tls_errors[] = {
     143              :     TLS_ERROR_FIELD(SSL_ERROR_NONE),
     144              :     TLS_ERROR_FIELD(SSL_ERROR_SSL),
     145              :     TLS_ERROR_FIELD(SSL_ERROR_WANT_READ),
     146              :     TLS_ERROR_FIELD(SSL_ERROR_WANT_WRITE),
     147              :     TLS_ERROR_FIELD(SSL_ERROR_WANT_X509_LOOKUP),
     148              :     TLS_ERROR_FIELD(SSL_ERROR_SYSCALL),
     149              :     TLS_ERROR_FIELD(SSL_ERROR_ZERO_RETURN),
     150              :     TLS_ERROR_FIELD(SSL_ERROR_WANT_CONNECT),
     151              :     TLS_ERROR_FIELD(SSL_ERROR_WANT_ACCEPT),
     152              : #ifndef LIBRESSL_VERSION_NUMBER
     153              : #if OPENSSL_VERSION_NUMBER >= 0x10100000L
     154              :     TLS_ERROR_FIELD(SSL_ERROR_WANT_ASYNC),
     155              :     TLS_ERROR_FIELD(SSL_ERROR_WANT_ASYNC_JOB),
     156              : #endif
     157              : #if OPENSSL_VERSION_NUMBER >= 0x10101000L
     158              :     TLS_ERROR_FIELD(SSL_ERROR_WANT_CLIENT_HELLO_CB),
     159              : #endif
     160              : #endif /* !LIBRESSL_VERSION_NUMBER */
     161              : };
     162              : const char *cert_errors[] = {
     163              :     TLS_ERROR_FIELD(X509_V_OK),
     164              : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
     165              :     TLS_ERROR_FIELD(X509_V_ERR_UNSPECIFIED),
     166              : #endif
     167              :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT),
     168              :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_CRL),
     169              :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE),
     170              :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE),
     171              :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY),
     172              :     TLS_ERROR_FIELD(X509_V_ERR_CERT_SIGNATURE_FAILURE),
     173              :     TLS_ERROR_FIELD(X509_V_ERR_CRL_SIGNATURE_FAILURE),
     174              :     TLS_ERROR_FIELD(X509_V_ERR_CERT_NOT_YET_VALID),
     175              :     TLS_ERROR_FIELD(X509_V_ERR_CERT_HAS_EXPIRED),
     176              :     TLS_ERROR_FIELD(X509_V_ERR_CRL_NOT_YET_VALID),
     177              :     TLS_ERROR_FIELD(X509_V_ERR_CRL_HAS_EXPIRED),
     178              :     TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD),
     179              :     TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD),
     180              :     TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD),
     181              :     TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD),
     182              :     TLS_ERROR_FIELD(X509_V_ERR_OUT_OF_MEM),
     183              :     TLS_ERROR_FIELD(X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT),
     184              :     TLS_ERROR_FIELD(X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN),
     185              :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY),
     186              :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE),
     187              :     TLS_ERROR_FIELD(X509_V_ERR_CERT_CHAIN_TOO_LONG),
     188              :     TLS_ERROR_FIELD(X509_V_ERR_CERT_REVOKED),
     189              :     TLS_ERROR_FIELD(X509_V_ERR_INVALID_CA),
     190              :     TLS_ERROR_FIELD(X509_V_ERR_PATH_LENGTH_EXCEEDED),
     191              :     TLS_ERROR_FIELD(X509_V_ERR_INVALID_PURPOSE),
     192              :     TLS_ERROR_FIELD(X509_V_ERR_CERT_UNTRUSTED),
     193              :     TLS_ERROR_FIELD(X509_V_ERR_CERT_REJECTED),
     194              :     TLS_ERROR_FIELD(X509_V_ERR_SUBJECT_ISSUER_MISMATCH),
     195              :     TLS_ERROR_FIELD(X509_V_ERR_AKID_SKID_MISMATCH),
     196              :     TLS_ERROR_FIELD(X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH),
     197              :     TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_CERTSIGN),
     198              :     TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER),
     199              :     TLS_ERROR_FIELD(X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION),
     200              :     TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_CRL_SIGN),
     201              :     TLS_ERROR_FIELD(X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION),
     202              :     TLS_ERROR_FIELD(X509_V_ERR_INVALID_NON_CA),
     203              :     TLS_ERROR_FIELD(X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED),
     204              :     TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE),
     205              :     TLS_ERROR_FIELD(X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED),
     206              :     TLS_ERROR_FIELD(X509_V_ERR_INVALID_EXTENSION),
     207              :     TLS_ERROR_FIELD(X509_V_ERR_INVALID_POLICY_EXTENSION),
     208              :     TLS_ERROR_FIELD(X509_V_ERR_NO_EXPLICIT_POLICY),
     209              :     TLS_ERROR_FIELD(X509_V_ERR_APPLICATION_VERIFICATION),
     210              : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
     211              :     TLS_ERROR_FIELD(X509_V_ERR_DIFFERENT_CRL_SCOPE),
     212              :     TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE),
     213              :     TLS_ERROR_FIELD(X509_V_ERR_UNNESTED_RESOURCE),
     214              :     TLS_ERROR_FIELD(X509_V_ERR_PERMITTED_VIOLATION),
     215              :     TLS_ERROR_FIELD(X509_V_ERR_EXCLUDED_VIOLATION),
     216              :     TLS_ERROR_FIELD(X509_V_ERR_SUBTREE_MINMAX),
     217              :     TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE),
     218              :     TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX),
     219              :     TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_NAME_SYNTAX),
     220              :     TLS_ERROR_FIELD(X509_V_ERR_CRL_PATH_VALIDATION_ERROR),
     221              : #ifndef LIBRESSL_VERSION_NUMBER
     222              :     TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_VERSION),
     223              :     TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_ALGORITHM),
     224              :     TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_CURVE),
     225              :     TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM),
     226              :     TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED),
     227              :     TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256),
     228              : #endif /* !LIBRESSL_VERSION_NUMBER */
     229              :     TLS_ERROR_FIELD(X509_V_ERR_HOSTNAME_MISMATCH),
     230              :     TLS_ERROR_FIELD(X509_V_ERR_EMAIL_MISMATCH),
     231              :     TLS_ERROR_FIELD(X509_V_ERR_IP_ADDRESS_MISMATCH),
     232              : #endif /* OPENSSL_VERSION_NUMBER >= 0x10002000L */
     233              : #if OPENSSL_VERSION_NUMBER >= 0x10100000L
     234              :     TLS_ERROR_FIELD(X509_V_ERR_INVALID_CALL),
     235              :     TLS_ERROR_FIELD(X509_V_ERR_STORE_LOOKUP),
     236              : #ifndef LIBRESSL_VERSION_NUMBER
     237              :     TLS_ERROR_FIELD(X509_V_ERR_PATH_LOOP),
     238              :     TLS_ERROR_FIELD(X509_V_ERR_DANE_NO_MATCH),
     239              :     TLS_ERROR_FIELD(X509_V_ERR_EE_KEY_TOO_SMALL),
     240              :     TLS_ERROR_FIELD(X509_V_ERR_CA_KEY_TOO_SMALL),
     241              :     TLS_ERROR_FIELD(X509_V_ERR_CA_MD_TOO_WEAK),
     242              :     TLS_ERROR_FIELD(X509_V_ERR_NO_VALID_SCTS),
     243              :     TLS_ERROR_FIELD(X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION),
     244              : #if OPENSSL_VERSION_NUMBER >= 0x10101000L
     245              :     TLS_ERROR_FIELD(X509_V_ERR_OCSP_VERIFY_NEEDED),
     246              :     TLS_ERROR_FIELD(X509_V_ERR_OCSP_VERIFY_FAILED),
     247              :     TLS_ERROR_FIELD(X509_V_ERR_OCSP_CERT_UNKNOWN),
     248              : #endif /* OPENSSL_VERSION_NUMBER >= 0x10101000L */
     249              : #endif /* !LIBRESSL_VERSION_NUMBER */
     250              : #endif /* OPENSSL_VERSION_NUMBER >= 0x10100000L */
     251              : };
     252              : #undef TLS_ERROR_FIELD
     253              : 
     254            2 : void tls_initialize(void)
     255              : {
     256              : #if OPENSSL_VERSION_NUMBER < 0x10100000L
     257              :     SSL_library_init();
     258              :     SSL_load_error_strings();
     259              : #else
     260            2 :     OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL);
     261              : #endif
     262              :     /* init xmppAddr OID */
     263            2 :     _tls_xaddr_nid();
     264            2 : }
     265              : 
     266            2 : void tls_shutdown(void)
     267              : {
     268              :     /*
     269              :      * FIXME: Don't free global tables, program or other libraries may use
     270              :      * openssl after libstrophe finalization. Maybe better leak some fixed
     271              :      * memory rather than cause random crashes of the main program.
     272              :      */
     273              : #if OPENSSL_VERSION_NUMBER < 0x10100000L
     274              :     OBJ_cleanup();
     275              :     ERR_free_strings();
     276              :     EVP_cleanup();
     277              :     CRYPTO_cleanup_all_ex_data();
     278              : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
     279              :     SSL_COMP_free_compression_methods();
     280              : #endif
     281              : #if OPENSSL_VERSION_NUMBER < 0x10000000L
     282              :     ERR_remove_state(0);
     283              : #else
     284              :     ERR_remove_thread_state(NULL);
     285              : #endif
     286              : #endif
     287            2 : }
     288              : 
     289            0 : int tls_error(struct conn_interface *intf)
     290              : {
     291            0 :     return intf->conn->tls->lasterror;
     292              : }
     293              : 
     294              : /** Search through the SubjectAlternativeNames and return the next
     295              :  *  id-on-xmppAddr element starting from `n`.
     296              :  */
     297           24 : char *tls_id_on_xmppaddr(xmpp_conn_t *conn, unsigned int n)
     298              : {
     299           24 :     char *ret = NULL;
     300           24 :     int i, j;
     301           24 :     GENERAL_NAMES *names = _tls_conn_get_names(conn);
     302           24 :     if (!names) {
     303            0 :         _tls_log_error(conn->ctx);
     304            0 :         return NULL;
     305              :     }
     306           24 :     int num_names = sk_GENERAL_NAME_num(names);
     307          104 :     for (i = j = 0; i < num_names; ++i) {
     308           72 :         char *res;
     309           72 :         GENERAL_NAME *name = sk_GENERAL_NAME_value(names, i);
     310           72 :         if (name == NULL)
     311              :             break;
     312           72 :         if (_tls_xmppaddr_to_string(name, &res))
     313           32 :             continue;
     314           40 :         if (j == (int)n) {
     315           16 :             strophe_debug(conn->ctx, "tls",
     316              :                           "extracted jid %s from id-on-xmppAddr", res);
     317           16 :             ret = strophe_strdup(conn->ctx, res);
     318           16 :             OPENSSL_free(res);
     319              :             break;
     320              :         }
     321           24 :         j++;
     322           24 :         OPENSSL_free(res);
     323              :     }
     324           24 :     GENERAL_NAMES_free(names);
     325           24 :     return ret;
     326              : }
     327              : 
     328            8 : unsigned int tls_id_on_xmppaddr_num(xmpp_conn_t *conn)
     329              : {
     330            8 :     unsigned int ret = 0;
     331            8 :     GENERAL_NAMES *names = _tls_conn_get_names(conn);
     332            8 :     if (!names) {
     333            0 :         _tls_log_error(conn->ctx);
     334            0 :         return 0;
     335              :     }
     336            8 :     int j, num_names = sk_GENERAL_NAME_num(names);
     337           48 :     for (j = 0; j < num_names; ++j) {
     338           32 :         GENERAL_NAME *name = sk_GENERAL_NAME_value(names, j);
     339           32 :         if (_tls_xmppaddr_to_string(name, NULL))
     340           16 :             continue;
     341           16 :         ret++;
     342              :     }
     343            8 :     GENERAL_NAMES_free(names);
     344            8 :     return ret;
     345              : }
     346              : 
     347            0 : static int _convert_ASN1TIME(ASN1_TIME *ansi_time, char *buf, size_t len)
     348              : {
     349            0 :     BIO *bio = BIO_new(BIO_s_mem());
     350            0 :     int rc = ASN1_TIME_print(bio, ansi_time);
     351            0 :     if (rc <= 0) {
     352            0 :         BIO_free(bio);
     353            0 :         return 0;
     354              :     }
     355            0 :     rc = BIO_gets(bio, buf, len);
     356            0 :     if (rc <= 0) {
     357            0 :         BIO_free(bio);
     358            0 :         return 0;
     359              :     }
     360            0 :     BIO_free(bio);
     361            0 :     return 1;
     362              : }
     363              : 
     364            0 : static char *_asn1_time_to_str(const xmpp_ctx_t *ctx, ASN1_TIME *t)
     365              : {
     366            0 :     char buf[128];
     367            0 :     int res = _convert_ASN1TIME(t, buf, sizeof(buf));
     368            0 :     if (res) {
     369            0 :         return strophe_strdup(ctx, buf);
     370              :     }
     371              :     return NULL;
     372              : }
     373              : 
     374              : static char *
     375            0 : _get_fingerprint(const xmpp_ctx_t *ctx, X509 *err_cert, xmpp_cert_element_t el)
     376              : {
     377            0 :     unsigned char buf[EVP_MAX_MD_SIZE];
     378            0 :     unsigned int len;
     379            0 :     const EVP_MD *digest;
     380            0 :     switch (el) {
     381            0 :     case XMPP_CERT_FINGERPRINT_SHA1:
     382            0 :         digest = EVP_sha1();
     383              :         break;
     384            0 :     case XMPP_CERT_FINGERPRINT_SHA256:
     385            0 :         digest = EVP_sha256();
     386              :         break;
     387              :     default:
     388            0 :         return NULL;
     389              :     }
     390            0 :     if (X509_digest(err_cert, digest, buf, &len) != 0) {
     391            0 :         char fingerprint[4 * EVP_MAX_MD_SIZE];
     392            0 :         hex_encode(fingerprint, buf, len);
     393            0 :         return strophe_strdup(ctx, fingerprint);
     394              :     }
     395              :     return NULL;
     396              : }
     397              : 
     398              : static char *
     399            0 : _get_alg(const xmpp_ctx_t *ctx, X509 *err_cert, xmpp_cert_element_t el)
     400              : {
     401            0 :     int alg_nid = NID_undef;
     402              : 
     403            0 :     switch (el) {
     404            0 :     case XMPP_CERT_KEYALG: {
     405              : #if OPENSSL_VERSION_NUMBER < 0x10100000L
     406              :         alg_nid = OBJ_obj2nid(err_cert->cert_info->key->algor->algorithm);
     407              : #else
     408            0 :         X509_PUBKEY *pubkey = X509_get_X509_PUBKEY(err_cert);
     409            0 :         ASN1_OBJECT *ppkalg = NULL;
     410            0 :         if (X509_PUBKEY_get0_param(&ppkalg, NULL, NULL, NULL, pubkey)) {
     411            0 :             alg_nid = OBJ_obj2nid(ppkalg);
     412              :         }
     413              : #endif
     414            0 :     } break;
     415            0 :     case XMPP_CERT_SIGALG: {
     416              : #if OPENSSL_VERSION_NUMBER < 0x10100000L
     417              :         alg_nid = OBJ_obj2nid(err_cert->sig_alg->algorithm);
     418              : #else
     419            0 :         const X509_ALGOR *palg;
     420            0 :         const ASN1_OBJECT *obj;
     421            0 :         X509_get0_signature(NULL, &palg, err_cert);
     422            0 :         X509_ALGOR_get0(&obj, NULL, NULL, palg);
     423            0 :         alg_nid = OBJ_obj2nid(obj);
     424              : #endif
     425            0 :     } break;
     426              :     default:
     427              :         break;
     428              :     }
     429            0 :     if (alg_nid != NID_undef) {
     430            0 :         const char *alg = OBJ_nid2ln(alg_nid);
     431            0 :         if (alg) {
     432            0 :             return strophe_strdup(ctx, alg);
     433              :         }
     434              :     }
     435              :     return NULL;
     436              : }
     437              : 
     438            0 : static xmpp_tlscert_t *_x509_to_tlscert(xmpp_ctx_t *ctx, X509 *cert)
     439              : {
     440            0 :     char *subject, *issuer, buf[32];
     441            0 :     xmpp_tlscert_t *tlscert = tlscert_new(ctx);
     442            0 :     if (!tlscert)
     443            0 :         return NULL;
     444              : 
     445            0 :     BIO *b = BIO_new(BIO_s_mem());
     446            0 :     if (!b)
     447            0 :         goto error_out;
     448            0 :     PEM_write_bio_X509(b, cert);
     449            0 :     BUF_MEM *bptr;
     450            0 :     BIO_get_mem_ptr(b, &bptr);
     451            0 :     tlscert->pem = strophe_alloc(ctx, bptr->length + 1);
     452            0 :     if (!tlscert->pem)
     453            0 :         goto error_out;
     454            0 :     memcpy(tlscert->pem, bptr->data, bptr->length);
     455            0 :     tlscert->pem[bptr->length] = '\0';
     456            0 :     BIO_free(b);
     457              : 
     458            0 :     subject = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
     459            0 :     if (!subject)
     460            0 :         goto error_out;
     461            0 :     tlscert->elements[XMPP_CERT_SUBJECT] = strophe_strdup(ctx, subject);
     462            0 :     OPENSSL_free(subject);
     463            0 :     issuer = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0);
     464            0 :     if (!issuer)
     465            0 :         goto error_out;
     466            0 :     tlscert->elements[XMPP_CERT_ISSUER] = strophe_strdup(ctx, issuer);
     467            0 :     OPENSSL_free(issuer);
     468              : 
     469            0 :     tlscert->elements[XMPP_CERT_NOTBEFORE] =
     470            0 :         _asn1_time_to_str(ctx, X509_get_notBefore(cert));
     471            0 :     tlscert->elements[XMPP_CERT_NOTAFTER] =
     472            0 :         _asn1_time_to_str(ctx, X509_get_notAfter(cert));
     473              : 
     474            0 :     tlscert->elements[XMPP_CERT_FINGERPRINT_SHA1] =
     475            0 :         _get_fingerprint(ctx, cert, XMPP_CERT_FINGERPRINT_SHA1);
     476            0 :     tlscert->elements[XMPP_CERT_FINGERPRINT_SHA256] =
     477            0 :         _get_fingerprint(ctx, cert, XMPP_CERT_FINGERPRINT_SHA256);
     478              : 
     479            0 :     strophe_snprintf(buf, sizeof(buf), "%ld", X509_get_version(cert) + 1);
     480            0 :     tlscert->elements[XMPP_CERT_VERSION] = strophe_strdup(ctx, buf);
     481              : 
     482            0 :     tlscert->elements[XMPP_CERT_KEYALG] = _get_alg(ctx, cert, XMPP_CERT_KEYALG);
     483            0 :     tlscert->elements[XMPP_CERT_SIGALG] = _get_alg(ctx, cert, XMPP_CERT_SIGALG);
     484              : 
     485            0 :     ASN1_INTEGER *serial = X509_get_serialNumber(cert);
     486            0 :     BIGNUM *bn = ASN1_INTEGER_to_BN(serial, NULL);
     487            0 :     if (bn) {
     488            0 :         char *serialnumber = BN_bn2hex(bn);
     489            0 :         if (serialnumber) {
     490            0 :             tlscert->elements[XMPP_CERT_SERIALNUMBER] =
     491            0 :                 strophe_strdup(ctx, serialnumber);
     492            0 :             OPENSSL_free(serialnumber);
     493              :         }
     494            0 :         BN_free(bn);
     495              :     }
     496              : 
     497            0 :     GENERAL_NAMES *names = _tls_cert_get_names(cert);
     498            0 :     if (names) {
     499            0 :         int j, num_names = sk_GENERAL_NAME_num(names);
     500              :         size_t n = 0;
     501            0 :         for (j = 0; j < num_names; ++j) {
     502            0 :             char *res;
     503            0 :             GENERAL_NAME *name = sk_GENERAL_NAME_value(names, j);
     504            0 :             if (_tls_dnsname_to_string(name, &res))
     505            0 :                 continue;
     506            0 :             if (tlscert_add_dnsname(tlscert, res))
     507            0 :                 strophe_debug(ctx, "tls", "Can't store dnsName(%zu): %s", n,
     508              :                               res);
     509            0 :             n++;
     510            0 :             OPENSSL_free(res);
     511              :         }
     512            0 :         GENERAL_NAMES_free(names);
     513              :     }
     514              : 
     515              :     return tlscert;
     516            0 : error_out:
     517            0 :     xmpp_tlscert_free(tlscert);
     518              :     return NULL;
     519              : }
     520              : 
     521            0 : static int _tls_verify(int preverify_ok, X509_STORE_CTX *x509_ctx)
     522              : {
     523            0 :     if (preverify_ok == 1)
     524              :         return 1;
     525              : 
     526            0 :     SSL *ssl = X509_STORE_CTX_get_ex_data(x509_ctx,
     527              :                                           SSL_get_ex_data_X509_STORE_CTX_idx());
     528            0 :     xmpp_conn_t *conn = SSL_get_app_data(ssl);
     529              : 
     530            0 :     if (!conn->certfail_handler) {
     531            0 :         strophe_error(conn->ctx, "tls",
     532              :                       "No certfail handler set, canceling connection attempt");
     533            0 :         return 0;
     534              :     }
     535              : 
     536            0 :     X509 *err_cert = X509_STORE_CTX_get_current_cert(x509_ctx);
     537              : 
     538            0 :     xmpp_tlscert_t *tlscert = _x509_to_tlscert(conn->ctx, err_cert);
     539              : 
     540            0 :     if (!tlscert)
     541              :         return 0;
     542              : 
     543            0 :     strophe_debug(conn->ctx, "tls", "preverify_ok:%d\nSubject: %s\nIssuer: %s",
     544              :                   preverify_ok, tlscert->elements[XMPP_CERT_SUBJECT],
     545              :                   tlscert->elements[XMPP_CERT_ISSUER]);
     546              : 
     547            0 :     int ret = conn->certfail_handler(
     548              :         tlscert,
     549            0 :         X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509_ctx)));
     550              : 
     551            0 :     xmpp_tlscert_free(tlscert);
     552              : 
     553            0 :     return ret;
     554              : }
     555              : 
     556            8 : static int _tls_password_callback(char *buf, int size, int rwflag, void *u)
     557              : {
     558            8 :     UNUSED(rwflag);
     559            8 :     return tls_caching_password_callback(buf, size, u);
     560              : }
     561              : 
     562              : #if OPENSSL_VERSION_NUMBER >= 0x10101000L
     563            0 : static void _keylog_cb(const SSL *ssl, const char *line)
     564              : {
     565            0 :     xmpp_conn_t *conn = SSL_get_app_data(ssl);
     566            0 :     fwrite(line, strlen(line), 1, conn->tls->keylogfile);
     567            0 :     fputc('\n', conn->tls->keylogfile);
     568            0 :     fflush(conn->tls->keylogfile);
     569            0 : }
     570              : #endif
     571              : 
     572            0 : static void _try_open_keylogfile(tls_t *tls)
     573              : {
     574              : #if OPENSSL_VERSION_NUMBER >= 0x10101000L
     575            0 :     const char *first_line = "# SSL Key logfile generated by libstrophe\n";
     576            0 :     const char *SSLKEYLOGFILE = getenv("SSLKEYLOGFILE");
     577            0 :     if (!SSLKEYLOGFILE || *SSLKEYLOGFILE == '\0')
     578              :         return;
     579            0 :     tls->keylogfile = fopen(SSLKEYLOGFILE, "abe");
     580            0 :     if (!tls->keylogfile) {
     581            0 :         strophe_warn(tls->ctx, "tls", "Could not open SSL keylog file %s",
     582              :                      SSLKEYLOGFILE);
     583            0 :         return;
     584              :     }
     585            0 :     fwrite(first_line, strlen(first_line), 1, tls->keylogfile);
     586            0 :     SSL_CTX_set_keylog_callback(tls->ssl_ctx, _keylog_cb);
     587              : #else
     588              :     UNUSED(tls);
     589              : #endif
     590              : }
     591              : 
     592            0 : tls_t *tls_new(xmpp_conn_t *conn)
     593              : {
     594            0 :     tls_t *tls = strophe_alloc(conn->ctx, sizeof(*tls));
     595              : 
     596            0 :     if (tls) {
     597            0 :         int ret;
     598              : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
     599              :         /* Hostname verification is supported in OpenSSL 1.0.2 and newer. */
     600            0 :         X509_VERIFY_PARAM *param;
     601              : #endif
     602            0 :         memset(tls, 0, sizeof(*tls));
     603              : 
     604            0 :         tls->ctx = conn->ctx;
     605            0 :         tls->sock = conn->sock;
     606              : #if OPENSSL_VERSION_NUMBER < 0x10100000L
     607              :         tls->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
     608              : #else
     609            0 :         tls->ssl_ctx = SSL_CTX_new(TLS_client_method());
     610              : #endif
     611            0 :         if (tls->ssl_ctx == NULL)
     612            0 :             goto err;
     613              : 
     614              :         /* Enable bug workarounds. */
     615            0 :         SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_ALL);
     616              : 
     617              :         /* Disable insecure SSL/TLS versions. */
     618            0 :         SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_SSLv2); /* DROWN */
     619            0 :         SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_SSLv3); /* POODLE */
     620            0 :         SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_TLSv1); /* BEAST */
     621              : 
     622            0 :         if (conn->password_callback) {
     623            0 :             SSL_CTX_set_default_passwd_cb(tls->ssl_ctx, _tls_password_callback);
     624            0 :             SSL_CTX_set_default_passwd_cb_userdata(tls->ssl_ctx, conn);
     625              :         }
     626              : 
     627            0 :         if (conn->tls_client_cert && conn->tls_client_key) {
     628            0 :             unsigned int retries = 0;
     629            0 :             tls->client_cert = _tls_cert_read(conn);
     630            0 :             if (!tls->client_cert) {
     631            0 :                 strophe_error(tls->ctx, "tls",
     632              :                               "could not read client certificate");
     633            0 :                 goto err_free_ctx;
     634              :             }
     635              : 
     636            0 :             SSL_CTX_use_certificate_file(tls->ssl_ctx, conn->tls_client_cert,
     637              :                                          SSL_FILETYPE_PEM);
     638            0 :             while (retries++ < conn->password_retries) {
     639            0 :                 if (SSL_CTX_use_PrivateKey_file(
     640            0 :                         tls->ssl_ctx, conn->tls_client_key, SSL_FILETYPE_PEM)) {
     641              :                     break;
     642              :                 }
     643            0 :                 tls_clear_password_cache(conn);
     644            0 :                 unsigned long err = ERR_peek_error();
     645            0 :                 if ((ERR_GET_LIB(err) == ERR_LIB_EVP &&
     646            0 :                      ERR_GET_REASON(err) == EVP_R_BAD_DECRYPT) ||
     647            0 :                     (ERR_GET_LIB(err) == ERR_LIB_PEM &&
     648            0 :                      ERR_GET_REASON(err) == PEM_R_BAD_DECRYPT)) {
     649            0 :                     strophe_debug(tls->ctx, "tls", "wrong password?");
     650            0 :                     continue;
     651              :                 }
     652            0 :                 strophe_error(tls->ctx, "tls",
     653              :                               "could not use private key %d %d",
     654              :                               ERR_GET_LIB(err), ERR_GET_REASON(err));
     655            0 :                 goto err_free_ctx;
     656              :             }
     657            0 :         } else if (conn->tls_client_cert) {
     658            0 :             EVP_PKEY *pkey = NULL;
     659            0 :             STACK_OF(X509) *ca = NULL;
     660            0 :             X509 *cert = _tls_cert_read_p12(conn, &pkey, &ca);
     661            0 :             if (!cert) {
     662            0 :                 goto err_free_ctx;
     663              :             }
     664              : 
     665            0 :             SSL_CTX_use_cert_and_key(tls->ssl_ctx, cert, pkey, ca, 1);
     666              : 
     667            0 :             if (pkey)
     668            0 :                 EVP_PKEY_free(pkey);
     669            0 :             if (ca)
     670            0 :                 sk_X509_pop_free(ca, X509_free);
     671            0 :             tls->client_cert = cert;
     672              :         } else {
     673              :             /* If the server asks for a client certificate, don't send one. */
     674            0 :             SSL_CTX_set_client_cert_cb(tls->ssl_ctx, NULL);
     675              :         }
     676              : 
     677            0 :         SSL_CTX_set_mode(tls->ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
     678              : 
     679            0 :         ret = SSL_CTX_set_default_verify_paths(tls->ssl_ctx);
     680            0 :         if (ret == 0 && !conn->tls_trust) {
     681              :             /*
     682              :              * Returns 1 on success and 0 on failure. A missing default
     683              :              * location is still treated as a success.
     684              :              * Ignore errors when XMPP_CONN_FLAG_TRUST_TLS is set.
     685              :              */
     686            0 :             strophe_error(tls->ctx, "tls",
     687              :                           "SSL_CTX_set_default_verify_paths() failed");
     688            0 :             goto err_free_cert;
     689              :         }
     690              : 
     691            0 :         if (conn->tls_cafile || conn->tls_capath) {
     692            0 :             if (SSL_CTX_load_verify_locations(tls->ssl_ctx, conn->tls_cafile,
     693            0 :                                               conn->tls_capath) == 0) {
     694            0 :                 strophe_error(tls->ctx, "tls",
     695              :                               "SSL_CTX_load_verify_locations() failed");
     696            0 :                 goto err_free_cert;
     697              :             }
     698              :         }
     699              : 
     700            0 :         tls->ssl = SSL_new(tls->ssl_ctx);
     701            0 :         if (tls->ssl == NULL)
     702            0 :             goto err_free_cert;
     703              : 
     704              : #if OPENSSL_VERSION_NUMBER >= 0x0908060L && !defined(OPENSSL_NO_TLSEXT)
     705              :         /* Enable SNI. */
     706            0 :         SSL_set_tlsext_host_name(tls->ssl, conn->domain);
     707              : #endif
     708              : 
     709              :         /* Trust server's certificate when user sets the flag explicitly.
     710              :          * Otherwise call the verification callback */
     711            0 :         if (conn->tls_trust)
     712            0 :             SSL_set_verify(tls->ssl, SSL_VERIFY_NONE, NULL);
     713              :         else
     714            0 :             SSL_set_verify(tls->ssl, SSL_VERIFY_PEER, _tls_verify);
     715            0 :         SSL_set_app_data(tls->ssl, conn);
     716              : #if OPENSSL_VERSION_NUMBER >= 0x10002000L
     717              :         /* Hostname verification is supported in OpenSSL 1.0.2 and newer. */
     718            0 :         param = SSL_get0_param(tls->ssl);
     719              : 
     720              :         /*
     721              :          * Allow only complete wildcards.  RFC 6125 discourages wildcard usage
     722              :          * completely, and lists internationalized domain names as a reason
     723              :          * against partial wildcards.
     724              :          * See https://tools.ietf.org/html/rfc6125#section-7.2 for more
     725              :          * information.
     726              :          */
     727            0 :         X509_VERIFY_PARAM_set_hostflags(param,
     728              :                                         X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
     729            0 :         X509_VERIFY_PARAM_set1_host(param, conn->domain, 0);
     730              : #endif
     731              : 
     732            0 :         ret = SSL_set_fd(tls->ssl, conn->sock);
     733            0 :         if (ret <= 0)
     734            0 :             goto err_free_ssl;
     735              : 
     736            0 :         _try_open_keylogfile(tls);
     737              :     }
     738              : 
     739              :     return tls;
     740              : 
     741            0 : err_free_ssl:
     742            0 :     SSL_free(tls->ssl);
     743            0 : err_free_cert:
     744            0 :     X509_free(tls->client_cert);
     745            0 : err_free_ctx:
     746            0 :     SSL_CTX_free(tls->ssl_ctx);
     747            0 : err:
     748            0 :     strophe_free(conn->ctx, tls);
     749            0 :     _tls_log_error(conn->ctx);
     750            0 :     return NULL;
     751              : }
     752              : 
     753            0 : void tls_free(tls_t *tls)
     754              : {
     755            0 :     if (tls->keylogfile)
     756            0 :         fclose(tls->keylogfile);
     757            0 :     strophe_free(tls->ctx, tls->channel_binding_data);
     758            0 :     SSL_free(tls->ssl);
     759            0 :     X509_free(tls->client_cert);
     760            0 :     SSL_CTX_free(tls->ssl_ctx);
     761            0 :     strophe_free(tls->ctx, tls);
     762            0 : }
     763              : 
     764            0 : xmpp_tlscert_t *tls_peer_cert(xmpp_conn_t *conn)
     765              : {
     766            0 :     if (conn && conn->tls && conn->tls->ssl) {
     767            0 :         X509 *cert = STROPHE_SSL_get1_peer_certificate(conn->tls->ssl);
     768            0 :         if (cert) {
     769            0 :             xmpp_tlscert_t *tlscert = _x509_to_tlscert(conn->ctx, cert);
     770            0 :             X509_free(cert);
     771            0 :             return tlscert;
     772              :         }
     773              :     }
     774              :     return NULL;
     775              : }
     776              : 
     777            0 : int tls_set_credentials(tls_t *tls, const char *cafilename)
     778              : {
     779            0 :     UNUSED(tls);
     780            0 :     UNUSED(cafilename);
     781            0 :     return -1;
     782              : }
     783              : 
     784            0 : int tls_init_channel_binding(tls_t *tls,
     785              :                              const char **binding_prefix,
     786              :                              size_t *binding_prefix_len)
     787              : {
     788            0 :     const char *label = NULL;
     789            0 :     size_t labellen = 0;
     790            0 :     int ssl_version = SSL_version(tls->ssl);
     791              : 
     792            0 :     switch (ssl_version) {
     793            0 :     case SSL3_VERSION:
     794            0 :         *binding_prefix = "tls-unique";
     795            0 :         *binding_prefix_len = strlen("tls-unique");
     796            0 :         tls->channel_binding_size = 36;
     797            0 :         break;
     798            0 :     case TLS1_VERSION:
     799              :     case TLS1_1_VERSION:
     800              :     case TLS1_2_VERSION:
     801            0 :         *binding_prefix = "tls-unique";
     802            0 :         *binding_prefix_len = strlen("tls-unique");
     803            0 :         tls->channel_binding_size = 12;
     804            0 :         break;
     805              : #ifdef TLS1_3_VERSION
     806            0 :     case TLS1_3_VERSION:
     807            0 :         label = "EXPORTER-Channel-Binding";
     808            0 :         labellen = 24;
     809            0 :         *binding_prefix = "tls-exporter";
     810            0 :         *binding_prefix_len = strlen("tls-exporter");
     811            0 :         tls->channel_binding_size = 32;
     812            0 :         break;
     813              : #endif
     814            0 :     default:
     815            0 :         strophe_error(tls->ctx, "tls", "Unsupported TLS/SSL Version: %s",
     816            0 :                       SSL_get_version(tls->ssl));
     817            0 :         return -1;
     818              :     }
     819              : 
     820            0 :     strophe_free_and_null(tls->ctx, tls->channel_binding_data);
     821            0 :     tls->channel_binding_data =
     822            0 :         strophe_alloc(tls->ctx, tls->channel_binding_size);
     823            0 :     if (!tls->channel_binding_data)
     824              :         return -1;
     825              : 
     826            0 :     if (ssl_version <= TLS1_2_VERSION) {
     827            0 :         size_t len;
     828            0 :         if (SSL_session_reused(tls->ssl)) {
     829            0 :             len = SSL_get_peer_finished(tls->ssl, tls->channel_binding_data,
     830              :                                         tls->channel_binding_size);
     831              :         } else {
     832            0 :             len = SSL_get_finished(tls->ssl, tls->channel_binding_data,
     833              :                                    tls->channel_binding_size);
     834              :         }
     835            0 :         if (len != tls->channel_binding_size) {
     836            0 :             strophe_error(tls->ctx, "tls",
     837              :                           "Got channel binding data of wrong size %zu", len);
     838            0 :             return -1;
     839              :         }
     840              :     } else {
     841            0 :         if (SSL_export_keying_material(tls->ssl, tls->channel_binding_data,
     842              :                                        tls->channel_binding_size, label,
     843              :                                        labellen, NULL, 0, 0) != 1) {
     844            0 :             strophe_error(tls->ctx, "tls",
     845              :                           "Could not get channel binding data");
     846            0 :             return -1;
     847              :         }
     848              :     }
     849              :     return 0;
     850              : }
     851              : 
     852            0 : const void *tls_get_channel_binding_data(tls_t *tls, size_t *size)
     853              : {
     854            0 :     if (!tls->channel_binding_data || !tls->channel_binding_size) {
     855            0 :         strophe_error(tls->ctx, "tls", "No channel binding data available");
     856              :     }
     857            0 :     *size = tls->channel_binding_size;
     858            0 :     return tls->channel_binding_data;
     859              : }
     860              : 
     861            0 : int tls_start(tls_t *tls)
     862              : {
     863            0 :     int error;
     864            0 :     int ret;
     865            0 :     long x509_res;
     866              : 
     867              :     /* Since we're non-blocking, loop the connect call until it
     868              :        succeeds or fails */
     869            0 :     while (1) {
     870            0 :         ret = SSL_connect(tls->ssl);
     871            0 :         error = ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0;
     872              : 
     873            0 :         if (ret == -1 && tls_is_recoverable(NULL, error)) {
     874              :             /* wait for something to happen on the sock before looping back */
     875            0 :             _tls_sock_wait(tls, error);
     876            0 :             continue;
     877              :         }
     878              : 
     879              :         /* success or fatal error */
     880            0 :         break;
     881              :     }
     882              : 
     883            0 :     x509_res = SSL_get_verify_result(tls->ssl);
     884            0 :     if (x509_res == X509_V_OK) {
     885            0 :         strophe_debug(tls->ctx, "tls", "Certificate verification passed");
     886              :     } else {
     887            0 :         strophe_debug(tls->ctx, "tls",
     888              :                       "Certificate verification FAILED, result=%s(%ld)",
     889              :                       TLS_ERROR_STR((int)x509_res, cert_errors), x509_res);
     890            0 :         if (ret > 0)
     891            0 :             strophe_debug(tls->ctx, "tls", "User decided to connect anyways");
     892              :     }
     893            0 :     _tls_dump_cert_info(tls);
     894              : 
     895            0 :     _tls_set_error(tls, error);
     896            0 :     return ret <= 0 ? 0 : 1;
     897              : }
     898              : 
     899            0 : int tls_stop(tls_t *tls)
     900              : {
     901            0 :     int retries = 0;
     902            0 :     int error;
     903            0 :     int ret;
     904              : 
     905              :     /* According to OpenSSL.org, we must not call SSL_shutdown(3)
     906              :        if a previous fatal error has occurred on a connection. */
     907            0 :     if (tls->lasterror == SSL_ERROR_SYSCALL || tls->lasterror == SSL_ERROR_SSL)
     908              :         return 1;
     909              : 
     910            0 :     while (1) {
     911            0 :         ++retries;
     912            0 :         ret = SSL_shutdown(tls->ssl);
     913            0 :         error = ret < 0 ? SSL_get_error(tls->ssl, ret) : 0;
     914            0 :         if (ret == 1 || !tls_is_recoverable(NULL, error) ||
     915              :             retries >= TLS_SHUTDOWN_MAX_RETRIES) {
     916              :             break;
     917              :         }
     918            0 :         _tls_sock_wait(tls, error);
     919              :     }
     920            0 :     if (error == SSL_ERROR_SYSCALL && errno == 0) {
     921              :         /*
     922              :          * Handle special case when peer closes connection instead of
     923              :          * proper shutdown.
     924              :          */
     925            0 :         error = 0;
     926            0 :         ret = 1;
     927              :     }
     928            0 :     _tls_set_error(tls, error);
     929              : 
     930            0 :     return ret <= 0 ? 0 : 1;
     931              : }
     932              : 
     933            0 : int tls_is_recoverable(struct conn_interface *intf, int error)
     934              : {
     935            0 :     UNUSED(intf);
     936            0 :     return (error == SSL_ERROR_NONE || error == SSL_ERROR_WANT_READ ||
     937            0 :             error == SSL_ERROR_WANT_WRITE || error == SSL_ERROR_WANT_CONNECT ||
     938              :             error == SSL_ERROR_WANT_ACCEPT);
     939              : }
     940              : 
     941            0 : int tls_pending(struct conn_interface *intf)
     942              : {
     943            0 :     return SSL_pending(intf->conn->tls->ssl);
     944              : }
     945              : 
     946            0 : int tls_read(struct conn_interface *intf, void *buff, size_t len)
     947              : {
     948            0 :     int ret;
     949            0 :     tls_t *tls = intf->conn->tls;
     950              : 
     951            0 :     ret = SSL_read(tls->ssl, buff, len);
     952            0 :     _tls_set_error(tls, ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0);
     953              : 
     954            0 :     return ret;
     955              : }
     956              : 
     957            0 : int tls_write(struct conn_interface *intf, const void *buff, size_t len)
     958              : {
     959            0 :     int ret;
     960            0 :     tls_t *tls = intf->conn->tls;
     961              : 
     962            0 :     ret = SSL_write(tls->ssl, buff, len);
     963            0 :     _tls_set_error(tls, ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0);
     964              : 
     965            0 :     return ret;
     966              : }
     967              : 
     968            0 : int tls_clear_pending_write(struct conn_interface *intf)
     969              : {
     970            0 :     UNUSED(intf);
     971            0 :     return 0;
     972              : }
     973              : 
     974            0 : static void _tls_sock_wait(tls_t *tls, int error)
     975              : {
     976            0 :     struct timeval tv;
     977            0 :     fd_set rfds;
     978            0 :     fd_set wfds;
     979            0 :     int nfds;
     980            0 :     int ret;
     981              : 
     982            0 :     if (error == SSL_ERROR_NONE)
     983            0 :         return;
     984              : 
     985            0 :     FD_ZERO(&rfds);
     986            0 :     FD_ZERO(&wfds);
     987            0 :     if (error == SSL_ERROR_WANT_READ)
     988            0 :         FD_SET(tls->sock, &rfds);
     989            0 :     if (error == SSL_ERROR_WANT_WRITE)
     990            0 :         FD_SET(tls->sock, &wfds);
     991            0 :     nfds = (error == SSL_ERROR_WANT_READ || error == SSL_ERROR_WANT_WRITE)
     992            0 :                ? tls->sock + 1
     993            0 :                : 0;
     994            0 :     do {
     995            0 :         tv.tv_sec = TLS_TIMEOUT_SEC;
     996            0 :         tv.tv_usec = TLS_TIMEOUT_USEC;
     997            0 :         ret = select(nfds, &rfds, &wfds, NULL, &tv);
     998            0 :     } while (ret == -1 && errno == EINTR);
     999              : }
    1000              : 
    1001            0 : static const char *_tls_error_str(int error, const char **tbl, size_t tbl_size)
    1002              : {
    1003            0 :     return (error >= 0 && (size_t)error < tbl_size) ? tbl[error] : "UNKNOWN";
    1004              : }
    1005              : 
    1006            0 : static void _tls_set_error(tls_t *tls, int error)
    1007              : {
    1008            0 :     if (error != 0 && !tls_is_recoverable(NULL, error)) {
    1009            0 :         strophe_debug(tls->ctx, "tls", "error=%s(%d) errno=%d lasterror=%d",
    1010            0 :                       TLS_ERROR_STR(error, tls_errors), error, errno,
    1011              :                       tls->lasterror);
    1012            0 :         _tls_log_error(tls->ctx);
    1013            0 :     } else if (tls->lasterror && tls->lasterror != error) {
    1014            0 :         strophe_debug_verbose(1, tls->ctx, "tls", "overwrite lasterror=%d",
    1015              :                               tls->lasterror);
    1016              :     }
    1017            0 :     tls->lasterror = error;
    1018            0 : }
    1019              : 
    1020            0 : static void _tls_log_error(xmpp_ctx_t *ctx)
    1021              : {
    1022            0 :     unsigned long e;
    1023              : 
    1024            0 :     do {
    1025            0 :         e = ERR_get_error();
    1026            0 :         if (e != 0) {
    1027            0 :             strophe_debug(
    1028              :                 ctx, "tls", "error:%08X:%s:%s:%s", e, ERR_lib_error_string(e),
    1029              :                 STROPHE_ERR_func_error_string(e), ERR_reason_error_string(e));
    1030              :         }
    1031            0 :     } while (e != 0);
    1032            0 : }
    1033              : 
    1034            0 : static void _tls_dump_cert_info(tls_t *tls)
    1035              : {
    1036            0 :     X509 *cert;
    1037            0 :     char *name;
    1038              : 
    1039            0 :     cert = STROPHE_SSL_get1_peer_certificate(tls->ssl);
    1040            0 :     if (cert == NULL)
    1041            0 :         strophe_debug(tls->ctx, "tls", "Certificate was not presented by peer");
    1042              :     else {
    1043            0 :         name = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
    1044            0 :         if (name != NULL) {
    1045            0 :             strophe_debug(tls->ctx, "tls", "Subject=%s", name);
    1046            0 :             OPENSSL_free(name);
    1047              :         }
    1048            0 :         name = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0);
    1049            0 :         if (name != NULL) {
    1050            0 :             strophe_debug(tls->ctx, "tls", "Issuer=%s", name);
    1051            0 :             OPENSSL_free(name);
    1052              :         }
    1053            0 :         X509_free(cert);
    1054              :     }
    1055            0 : }
    1056              : 
    1057            8 : static X509 *_tls_cert_read_x509(xmpp_conn_t *conn)
    1058              : {
    1059            8 :     if (conn->tls && conn->tls->client_cert)
    1060              :         return conn->tls->client_cert;
    1061            8 :     BIO *f = BIO_new_file(conn->tls_client_cert, "r");
    1062            8 :     if (!f) {
    1063            0 :         strophe_debug(conn->ctx, "tls", "f == NULL");
    1064            0 :         return NULL;
    1065              :     }
    1066            8 :     X509 *c = PEM_read_bio_X509(f, NULL, NULL, NULL);
    1067            8 :     BIO_free(f);
    1068            8 :     if (!c) {
    1069            0 :         _tls_log_error(conn->ctx);
    1070              :     }
    1071              :     return c;
    1072              : }
    1073              : 
    1074           32 : static int _tls_parse_p12(PKCS12 *p12,
    1075              :                           const char *pass,
    1076              :                           EVP_PKEY **pkey,
    1077              :                           X509 **cert,
    1078              :                           STACK_OF(X509) * *ca)
    1079              : {
    1080              :     /* For some reason `PKCS12_parse()` fails without a `EVP_PKEY`
    1081              :      * so if the user doesn't want it, use a local one and free it
    1082              :      * again directly after parsing.
    1083              :      */
    1084           32 :     EVP_PKEY *pkey_;
    1085           32 :     if (!pkey)
    1086           32 :         pkey = &pkey_;
    1087           32 :     int parse_ok = PKCS12_parse(p12, pass, pkey, cert, ca);
    1088           32 :     if (pkey == &pkey_ && pkey_)
    1089           24 :         EVP_PKEY_free(pkey_);
    1090           32 :     return parse_ok;
    1091              : }
    1092              : 
    1093              : static X509 *
    1094           24 : _tls_cert_read_p12(xmpp_conn_t *conn, EVP_PKEY **pkey, STACK_OF(X509) * *ca)
    1095              : {
    1096           24 :     if (conn->tls && conn->tls->client_cert && !pkey && !ca)
    1097           24 :         return conn->tls->client_cert;
    1098           24 :     X509 *cert = NULL;
    1099           24 :     PKCS12 *p12 = NULL;
    1100           24 :     BIO *f = BIO_new_file(conn->tls_client_cert, "rb");
    1101           24 :     if (!f) {
    1102            0 :         strophe_debug(conn->ctx, "tls", "f == NULL");
    1103            0 :         goto error_out;
    1104              :     }
    1105           24 :     p12 = d2i_PKCS12_bio(f, NULL);
    1106           24 :     BIO_free(f);
    1107           24 :     if (!p12) {
    1108            0 :         strophe_debug(conn->ctx, "tls", "Could not read p12 file");
    1109            0 :         goto error_out;
    1110              :     }
    1111              : 
    1112              :     /* First try to open file w/o a pass */
    1113           24 :     if (_tls_parse_p12(p12, NULL, pkey, &cert, ca)) {
    1114           16 :         goto success;
    1115              :     }
    1116            8 :     cert = NULL;
    1117              : 
    1118            8 :     unsigned int retries = 0;
    1119              : 
    1120            8 :     pem_password_cb *cb = PEM_def_callback;
    1121            8 :     void *userdata = NULL;
    1122            8 :     if (conn->password_callback) {
    1123            8 :         cb = _tls_password_callback;
    1124            8 :         userdata = conn;
    1125              :     }
    1126              : 
    1127            8 :     while (retries++ < conn->password_retries) {
    1128            8 :         char pass[PEM_BUFSIZE + 1];
    1129            8 :         int passlen = cb(pass, PEM_BUFSIZE, 0, userdata);
    1130            8 :         if (passlen < 0 || passlen > PEM_BUFSIZE)
    1131            0 :             goto error_out;
    1132            8 :         int parse_ok = _tls_parse_p12(p12, pass, pkey, &cert, ca);
    1133            8 :         if (parse_ok) {
    1134            8 :             goto success;
    1135              :         }
    1136            0 :         cert = NULL;
    1137            0 :         tls_clear_password_cache(conn);
    1138            0 :         int err = ERR_peek_last_error();
    1139            0 :         if (ERR_GET_LIB(err) == ERR_LIB_PKCS12 &&
    1140            0 :             ERR_GET_REASON(err) == PKCS12_R_MAC_VERIFY_FAILURE) {
    1141            0 :             strophe_debug(conn->ctx, "tls",
    1142              :                           "Entered password is most likely wrong!");
    1143            0 :             continue;
    1144              :         }
    1145            0 :         strophe_debug(conn->ctx, "tls", "Could not parse PKCS#12");
    1146            0 :         goto error_out;
    1147              :     }
    1148            0 : error_out:
    1149            0 :     _tls_log_error(conn->ctx);
    1150           24 : success:
    1151           24 :     if (p12)
    1152           24 :         PKCS12_free(p12);
    1153           24 :     return cert;
    1154              : }
    1155              : 
    1156           32 : static X509 *_tls_cert_read(xmpp_conn_t *conn)
    1157              : {
    1158           32 :     if (conn->tls && conn->tls->client_cert)
    1159              :         return conn->tls->client_cert;
    1160           32 :     if (conn->tls_client_cert && !conn->tls_client_key) {
    1161           24 :         return _tls_cert_read_p12(conn, NULL, NULL);
    1162              :     }
    1163            8 :     return _tls_cert_read_x509(conn);
    1164              : }
    1165              : 
    1166           58 : static int _tls_xaddr_nid(void)
    1167              : {
    1168           58 :     static int xaddr_nid = NID_undef;
    1169           58 :     if (xaddr_nid == NID_undef) {
    1170            2 :         xaddr_nid = OBJ_sn2nid("id-on-xmppAddr");
    1171              :     }
    1172           58 :     if (xaddr_nid == NID_undef) {
    1173            0 :         xaddr_nid = OBJ_create("1.3.6.1.5.5.7.8.5", "id-on-xmppAddr",
    1174              :                                "XmppAddr Identifier");
    1175              :     }
    1176           58 :     return xaddr_nid;
    1177              : }
    1178              : 
    1179           32 : static GENERAL_NAMES *_tls_conn_get_names(xmpp_conn_t *conn)
    1180              : {
    1181           32 :     X509 *client_cert;
    1182           32 :     GENERAL_NAMES *names = NULL;
    1183           32 :     client_cert = _tls_cert_read(conn);
    1184           32 :     if (!client_cert)
    1185              :         return NULL;
    1186           32 :     names = _tls_cert_get_names(client_cert);
    1187           32 :     if (!conn->tls || !conn->tls->client_cert)
    1188           32 :         X509_free(client_cert);
    1189              :     return names;
    1190              : }
    1191              : 
    1192           32 : static GENERAL_NAMES *_tls_cert_get_names(X509 *client_cert)
    1193              : {
    1194           32 :     int san = X509_get_ext_by_NID(client_cert, NID_subject_alt_name, 0);
    1195           32 :     X509_EXTENSION *san_ext = X509_get_ext(client_cert, san);
    1196           32 :     if (!san_ext)
    1197           32 :         return NULL;
    1198           32 :     ASN1_OCTET_STRING *data = X509_EXTENSION_get_data(san_ext);
    1199           32 :     if (!data)
    1200              :         return NULL;
    1201           32 :     const unsigned char *d = ASN1_STRING_get0_data(data);
    1202           32 :     if (!d)
    1203              :         return NULL;
    1204           32 :     return d2i_GENERAL_NAMES(NULL, &d, ASN1_STRING_length(data));
    1205              : }
    1206              : 
    1207              : /** Convert GENERAL_NAME* to a string
    1208              :  *
    1209              :  *  This checks whether the GENERAL_NAME* that is given has the
    1210              :  *  correct id-on-xmppAddr set and then optionally converts this
    1211              :  *  form ASN.1 to a string/char*.
    1212              :  *
    1213              :  *  When `res` pointer is set to NULL this method doesn't allocate
    1214              :  *  the result but only checks whether it is in the correct format.
    1215              :  *
    1216              :  *  @param name Pointer to the GENERAL_NAME that shall be converted
    1217              :  *  @param res Result-pointer (optional, can be NULL)
    1218              :  *
    1219              :  *  @return classic Unix style - 0=success, 1=error
    1220              :  */
    1221          104 : static int _tls_xmppaddr_to_string(GENERAL_NAME *name, char **res)
    1222              : {
    1223          104 :     ASN1_OBJECT *oid;
    1224          104 :     ASN1_TYPE *val;
    1225          104 :     if (!name || name->type != GEN_OTHERNAME)
    1226          104 :         return 1;
    1227           56 :     if (GENERAL_NAME_get0_otherName(name, &oid, &val) == 0)
    1228              :         return 1;
    1229           56 :     if (OBJ_obj2nid(oid) != _tls_xaddr_nid() || !val)
    1230              :         return 1;
    1231           56 :     if (!res)
    1232              :         return 0;
    1233           40 :     if (ASN1_STRING_to_UTF8((unsigned char **)res, val->value.asn1_string) < 0)
    1234              :         return 1;
    1235              :     return 0;
    1236              : }
    1237              : 
    1238            0 : static int _tls_dnsname_to_string(GENERAL_NAME *name, char **res)
    1239              : {
    1240            0 :     ASN1_STRING *str;
    1241            0 :     if (!name || name->type != GEN_DNS)
    1242              :         return 1;
    1243            0 :     str = GENERAL_NAME_get0_value(name, NULL);
    1244            0 :     if (str == NULL)
    1245              :         return 1;
    1246            0 :     if (!res)
    1247              :         return 0;
    1248            0 :     if (ASN1_STRING_to_UTF8((unsigned char **)res, str) < 0)
    1249              :         return 1;
    1250              :     return 0;
    1251              : }
        

Generated by: LCOV version 2.0-1